// // SPDX-License-Identifier: MIT
// pragma solidity ^0.5.0;

// library SafeMath {
//     function add(uint256 a,uint256 b) internal pure returns (uint256) {
//         uint256 c = a+b;
//         require(c >= a, "SafeMath: addition overflow");
//         return c;
//     }
//     function sub(uint256 a,uint256 b) internal pure returns (uint256) {
//         return sub(a,b,"SafeMath: subtraction overflow");
//     }
//     function sub(uint256 a,uint256 b,string memory errorMessage) internal pure returns (uint256) {
//         require(b <= a, errorMessage);
//         uint256 c = a - b;
//         return c;
//     }
//     function mul(uint256 a,uint256 b) internal pure returns (uint256) {
//         if (a == 0) {
//             return 0;
//         }
//         uint256 c = a*b;
//         require(c/a == b, "SafeMath:muliplication overflow");
//         return c;
//     }
//     function div(uint256 a,uint256 b) internal pure returns (uint256) {
//         return div(a,b,"SafeMath: division by zero");
//     }
//     function div(uint256 a,uint256 b,string memory errorMessage) internal pure returns (uint256) {
//         require(b > 0,errorMessage);
//         uint256 c = a/b;
//         return c;
//     }
//     function mod(uint256 a,uint256 b,string memory errorMessage) internal pure returns (uint256) {
//         require(b != 0, errorMessage);
//         return a % b;
//     }
// }

// interface IERC20 {
//     function totalSupply() external view returns (uint256);
//     function balanceOf(address account) external view returns (uint256);
//     function transfer(address recipient,uint256 amount) external returns (bool);
//     function allowance(address owner,address spender) external view returns (uint256);
//     function approve(address spender,uint256 amount) external returns (bool);
//     function transferFrom(address sender,address recipient,uint256 amount) external returns (bool);

//     event Transfer(address indexed from,address indexed to,uint256 value);
//     event Approval(address indexed owner,address indexed spender,uint256 value);
// }

// contract ERC20GuDingToken is IERC20 {
//     using SafeMath for uint256;

//     // string private _name = "Hello World Token";
//     // string private _symbol = "HWT";
//     // uint8 private _decimals = 18;
//     // uint256 private _totalSupply = 21000000*(10**uint256(_decimals));

//     string  private _name ;
//     string  private _symbol ;
//     uint8   private _decimals;
//     uint256 private _totalSupply;

//     mapping (address => uint256) private _balances;
//     mapping (address => mapping (address => uint256)) private _allowances;

//     constructor(string memory name,string memory symbol,uint8 decimals,uint256 totalSupply) public {
//         _name        = name;
//         _symbol      = symbol;
//         _decimals    = decimals;
//         _totalSupply = totalSupply*(10**uint256(_decimals));
//         _balances[msg.sender] = _totalSupply;
//     }

//     function name() public view returns (string memory) {
//         return _name;
//     }
    
//     function symbol() public view returns (string memory) {
//         return _symbol;
//     }

//     function decimals() public view returns (uint8) {
//         return _decimals;
//     }

//     function totalSupply() public view returns (uint256) {
//         return _totalSupply;
//     }

//     function balanceOf(address account) public  view returns (uint256) {
//         return _balances[account];
//     }

//     function allowance(address owner, address spender) public  view returns (uint256) {
//         return _allowances[owner][spender];
//     }

//     function transfer(address recipient, uint256 amount) public  returns (bool) {
//         _transfer(msg.sender, recipient, amount);
//         return true;
//     }

//     function approve(address spender, uint256 amount) public  returns (bool) {
//         _approve(msg.sender, spender, amount);
//         return true;
//     }

//     function transferFrom(address sender, address recipient, uint256 amount) public  returns (bool) {
//         _transfer(sender,recipient,amount);
//         _approve(sender,msg.sender,_allowances[sender][msg.sender].sub(amount,"ERC20:transfer amount exceeds allowance"));
//         return true;
//     }

//     function increaseAllowance(address spender,uint256 addedValue) public returns (bool) {
//         _approve(msg.sender,spender,_allowances[msg.sender][spender].add(addedValue));
//         return true;
//     }

//     function decreaseAllowance(address spender,uint256 subtractedValue) public returns (bool) {
//         _approve(msg.sender,spender, _allowances[msg.sender][spender].sub(subtractedValue,"ERC20:decreased allowance below zero"));
//         return true;
//     }

//     function _transfer(address sender,address recipient, uint256 amount) internal {
//         require(sender != address(0), "ERC20:transfer from the zero address");
//         require(recipient != address(0), "ERC20:transfer to the zero address");

//         _balances[sender] = _balances[sender].sub(amount,"ERC20:transfer amount exceeds balance");
//         _balances[recipient] = _balances[recipient].add(amount);
//         emit Transfer(sender, recipient, amount);
//     }

//     function _approve(address owner, address spender, uint256 amount) internal {
//         require(owner != address(0), "ERC20:transfer from the zero address");
//         require(spender != address(0), "ERC20:transfer to the zero address");

//         _allowances[owner][spender] = amount;
//         emit Approval(owner, spender, amount);
//     }
// }

